Page({
  /**
   * 页面的初始数据
   */
  data: {
    activeKey: 0, // 当前激活的分类索引
    categoryItems: [], // 存储所有分类
    scrollToId: "", // 用于 scroll-into-view 的 ID
    sectionHeights: [], // 每个分类的高度位置
    show: false, // 弹出层
    selectedItem: {
      // 假设商品中有一个 id 字段，便于唯一标识
      id: '',
      name: '',
      detail: '',
      coverUrl: '',
      showPriceLow: 20, // 商品基础价格
    },
    // 加料选项及其价格
    toppings: [{
        id: 1,
        name: '珍珠',
        price: 3,
        quantity: 0
      },
      {
        id: 2,
        name: '椰果',
        price: 4,
        quantity: 0
      },
      {
        id: 3,
        name: '芋圆',
        price: 5,
        quantity: 0
      },
    ],
    // 用户选择
    cupType: '',
    sweetness: '',
    temperature: '',
    cupOptions: [{
        name: '大杯520ml'
      },
      {
        name: '小杯360ml'
      }
    ],
    sweetnessOptions: [{
        name: '无糖'
      },
      {
        name: '少糖'
      },
      {
        name: '正常'
      }
    ],
    temperatureOptions: [{
        name: '少冰'
      },
      {
        name: '去冰'
      },
      {
        name: '温热'
      }
    ],
    totalPrice: 20, // 默认总价
    quantity: 1, // 购买数量（步进器的值）
    cartTotalPrice: 0, // 总价
    cart: [], // 购物车数据
    cartItemCount: 0, // 购物车中的商品总数量
    showCartPopup: false, // 控制购物车底部弹窗的显示
    cartItems: [], // 存储购物车中的商品
    cartVisible: false, // 控制购物车悬浮框是否显示
    userInfo: null,
    hasUserInfo: false,
    showActionSheet: false,
  },
  // 更新购物车悬浮框的显示状态
  updateCartVisibility() {
    const app = getApp();
    const cart = app.globalData.cart || [];
    const hasItems = cart.length > 0; // 判断购物车中是否有商品
    this.setData({
      cartVisible: hasItems
    });
  },
  // 显示购物车底部弹窗
  showCartPopup() {
    const app = getApp();
    const cart = app.globalData.cart || [];
    this.setData({
      showCartPopup: true,
      cartItems: cart
    });
  },

  // 关闭购物车弹窗
  closeCartPopup() {
    this.setData({
      showCartPopup: false
    });
  },
  onShow() {
    // 页面显示时计算总价
    this.updateCartTotalPrice();
  },

  // 计算购物车总价
  updateCartTotalPrice() {
    const app = getApp();
    const cart = app.globalData.cart || [];

    // 累加所有商品的总价（注意，每个商品的 totalPrice 已经是最终值）
    const totalPrice = cart.reduce((sum, item) => sum + item.totalPrice, 0);

    // 计算购物车中所有商品的数量
    const cartItemCount = cart.reduce((count, item) => count + item.quantity, 0);

    this.setData({
      cartTotalPrice: totalPrice.toFixed(2), // 保留两位小数
      cartItemCount
    });
  },



  // 显示选择规格的弹出层，并重置部分数据（例如数量）
  showPopup(event) {
    const item = event.currentTarget.dataset.item; // 获取商品数据
    this.setData({
      show: true, // 显示弹出层
      selectedItem: item, // 更新选中商品数据
      totalPrice: item.showPriceLow, // 重置总价为基础价格
      quantity: 1, // 重置购买数量为1
      // 同时可以重置其他选择项（杯型、甜度、温度、加料）
      cupType: '',
      sweetness: '',
      temperature: '',
      toppings: this.data.toppings.map(t => ({
        ...t,
        quantity: 0,
        active: false
      })),
    });
  },

  onClose() {
    this.setData({
      show: false
    });
  },

  // 杯型选择
  onCupTypeChange(e) {
    const {
      name
    } = e.currentTarget.dataset;
    this.setData({
      cupType: name
    });
  },

  // 甜度选择
  onSweetnessChange(e) {
    const {
      name
    } = e.currentTarget.dataset;
    this.setData({
      sweetness: name
    });
  },

  // 温度选择
  onTemperatureChange(e) {
    const {
      name
    } = e.currentTarget.dataset;
    this.setData({
      temperature: name
    });
  },

  // 点击加料项，增加数量
  onToppingIncrease(event) {
    const {
      id
    } = event.currentTarget.dataset;
    const toppings = this.data.toppings.map(topping => {
      if (topping.id === id) {
        topping.quantity += 1;
      }
      return topping;
    });
    this.setData({
      toppings
    }, this.calculateTotalPrice);
    this.updateActiveTopping();
  },

  // 点击加料项，减少数量
  onToppingDecrease(event) {
    const {
      id
    } = event.currentTarget.dataset;
    const toppings = this.data.toppings.map(topping => {
      if (topping.id === id && topping.quantity > 0) {
        topping.quantity -= 1;
      }
      return topping;
    });
    this.setData({
      toppings
    }, this.calculateTotalPrice);
    this.updateActiveTopping();
  },

  // 更新选中状态的高亮样式
  updateActiveTopping() {
    const toppings = this.data.toppings.map(topping => {
      topping.active = topping.quantity >= 1;
      return topping;
    });
    this.setData({
      toppings
    });
  },

  // 计算总价（此处可以根据需求修改，比如包含购买数量）
  calculateTotalPrice() {
    const basePrice = this.data.selectedItem.showPriceLow;
    const toppingsPrice = this.data.toppings.reduce((sum, topping) => {
      return sum + (topping.quantity * topping.price);
    }, 0);
    // 如果需要根据购买数量计算总价，则乘以数量
    const totalPrice = (basePrice + toppingsPrice) * this.data.quantity;
    this.setData({
      totalPrice
    });
  },

  // 步进器数值变化处理函数
  onChange(event) {
    const quantity = event.detail; // 获取步进器的值
    this.setData({
      quantity
    }, this.calculateTotalPrice);
  },
  // 步进器数值变化处理函数，用于购物车商品数量的修改
  onCartItemChange(event) {
    const app = getApp();
    const index = event.currentTarget.dataset.index; // 获取商品的索引
    const quantity = event.detail; // 获取步进器的值

    // 更新购物车中的商品数量
    const cart = app.globalData.cart.map((item, idx) => {
      if (idx === index) {
        return {
          ...item,
          quantity: quantity,
          totalPrice: item.item.showPriceLow * quantity + item.options.toppings.reduce((sum, topping) => sum + (topping.quantity * topping.price), 0)
        };
      }
      console.log('购物车数据：', app.globalData.cart);
      return item;
    });

    // 更新全局数据
    app.globalData.cart = cart;
    wx.setStorageSync('cart', app.globalData.cart);

    // 更新购物车总价和可见状态
    this.updateCartTotalPrice();
    this.updateCartVisibility();
  },
  /**
   * 加入购物车的逻辑
   */
  addToCart() {
    const {
      selectedItem,
      cupType,
      sweetness,
      temperature,
      toppings,
      quantity
    } = this.data;

    // 检查是否选择了杯型、甜度和温度
    if (!cupType || !sweetness || !temperature) {
      wx.showToast({
        title: '请先选择规格',
        icon: 'none',
        duration: 2000
      });
      return; // 如果没有选择这些，直接返回，不执行加入购物车操作
    }

    // 计算单件商品选中小料的总价
    let unitToppingsPrice = 0;
    // 过滤出数量大于 0 的小料，并更新其数量为“单件小料数量 * 购买数量”
    const updatedToppings = toppings.filter(t => t.quantity > 0).map(t => {
      unitToppingsPrice += t.quantity * t.price;
      return {
        ...t,
        // 扩展小料数量，使其反映多件商品
        quantity: t.quantity * quantity
      };
    });

    // 计算整个商品的总价：基础单价 + 单件小料总价，再乘以购买数量
    const itemTotalPrice = (selectedItem.showPriceLow + unitToppingsPrice) * quantity;

    // 构造购物车项
    const cartItem = {
      id: selectedItem.id || new Date().getTime(),
      item: selectedItem,
      options: {
        cupType,
        sweetness,
        temperature,
        toppings: updatedToppings // 存储已经扩展了数量的小料
      },
      quantity, // 商品数量
      totalPrice: itemTotalPrice, // 计算后的总价
      addedAt: new Date().getTime()
    };

    const app = getApp();
    if (!app.globalData.cart) {
      app.globalData.cart = [];
    }
    app.globalData.cart.push(cartItem);
    wx.setStorageSync('cart', app.globalData.cart);

    wx.showToast({
      title: '已加入购物车',
      icon: 'success',
      duration: 2000
    });

    // 更新购物车总价和可见状态
    this.updateCartTotalPrice();
    this.updateCartVisibility();
    // 重置步进器的值和总价显示（恢复为单杯的基础价格）
    this.setData({
      quantity: 1,
      totalPrice: selectedItem.showPriceLow
    });

    this.setData({
      show: false
    });
  },



  clearCart() {
    const app = getApp();
    app.globalData.cart = [];
    wx.setStorageSync('cart', []);

    this.setData({
      cartItems: [],
      cartTotalPrice: 0,
      cartItemCount: 0,
      cartVisible: false,
      showCartPopup: false
    });

    wx.showToast({
      title: '购物车已清空',
      icon: 'none',
      duration: 2000
    });
  },

  // 获取用户信息和登录凭证（支持传入登录完成后的回调）
  getUserProfile(callback) {
    wx.getUserProfile({
      desc: '用于完善会员资料',
      success: (res) => {
        this.setData({
          userInfo: res.userInfo,
          hasUserInfo: true,
          showActionSheet: false, // 登录成功后关闭弹框
        });

        // 调用 wx.login 获取 code
        wx.login({
          success: (loginRes) => {
            if (loginRes.code) {
              console.log('登录凭证:', loginRes.code);
              // 调用云函数，传递 code 和用户信息
              wx.cloud.callFunction({
                name: 'login', // 云函数名
                data: {
                  code: loginRes.code || '', // 确保 code 不为空
                  userInfo: res.userInfo || {}, // 确保 userInfo 是对象
                },
                success: (cloudRes) => {
                  console.log('云函数返回:', cloudRes.result);
                  if (cloudRes.result.success) {
                    const openid = cloudRes.result.openid; // 获取 openid

                    // 获取云数据库引用
                    const db = wx.cloud.database();
                    const usersCollection = db.collection('users');

                    // 查询是否已存在该用户
                    usersCollection.where({
                      _openid: openid
                    }).get().then(queryRes => {
                      console.log('查询结果:', queryRes);
                      if (queryRes.data.length === 0) {
                        // 未找到用户，创建新用户
                        const openidRandom = this.generateRandomString(24); // 生成随机字符串
                        usersCollection.doc(openidRandom).set({
                          data: {
                            userInfo: {
                              nickName: res.userInfo.nickName,
                              avatarUrl: res.userInfo.avatarUrl,
                            },
                            updateTime: new Date().toISOString().slice(0, 10),
                          },
                          success: (dbRes) => {
                            console.log('用户信息存储成功:', dbRes);
                            wx.setStorageSync('openidRandom', openidRandom);
                            // 登录流程完成后调用回调（如果存在）
                            callback && callback();
                          },
                          fail: (err) => {
                            console.error('用户信息存储失败:', err);
                          }
                        });
                      } else {
                        // 已存在用户，更新信息
                        const openidRandom = queryRes.data[0]._id;
                        usersCollection.doc(openidRandom).update({
                          data: {
                            userInfo: {
                              nickName: res.userInfo.nickName,
                              avatarUrl: res.userInfo.avatarUrl,
                            },
                          },
                          success: (dbRes) => {
                            console.log('用户信息更新成功:', dbRes);
                            wx.setStorageSync('openidRandom', openidRandom);
                            // 登录流程完成后调用回调（如果存在）
                            callback && callback();
                          },
                          fail: (err) => {
                            console.error('用户信息更新失败:', err);
                          }
                        });
                      }
                    }).catch(err => {
                      console.error('查询用户信息失败:', err);
                    });
                  } else {
                    console.error('云函数返回失败:', cloudRes.result.error);
                  }
                },
                fail: (err) => {
                  console.error('调用云函数失败:', err);
                }
              });
            } else {
              console.error('登录失败:', loginRes.errMsg);
            }
          }
        });
      },
      fail: (err) => {
        console.error('获取用户信息失败:', err);
      }
    });
  },

  // 生成随机字符串的方法（用于生成 openidRandom）
  generateRandomString(length) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < length; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  },
 // 结算订单方法
 onCheckout() {
  const app = getApp();
  const cartItems = app.globalData.cart || [];

  if (cartItems.length === 0) {
    wx.showToast({
      title: '购物车为空',
      icon: 'none',
      duration: 2000
    });
    return;
  }

    // 检查是否登录（openidRandom 是否存在）
    const openidRandom = wx.getStorageSync('openidRandom');
    if (!openidRandom) {
      // 自动调用登录流程，登录完成后再重新执行 onCheckout
        // 气泡提示“请先登录”
        wx.showToast({
          title: '请先登录',
          icon: 'none',
          duration: 2000
        });
      this.getUserProfile(() => {
        this.onCheckout(); // 登录成功后再次执行结算逻辑
      });
      return;
    }

  // 组装订单数据……
  const orderData = {
    userId: wx.getStorageSync('userId') || 'unknown',
    orderId: new Date().getTime(),
    items: [...cartItems],
    totalPrice: parseFloat(this.data.cartTotalPrice),
    createdAt: new Date(),
    openidRandom: openidRandom,
    orderStatus: '未付款'
  };

  app.globalData.orderData = orderData;
  console.log("订单数据已存入 globalData:", app.globalData.orderData);

  const db = wx.cloud.database();
  db.collection('orders').add({
    data: orderData
  }).then(res => {
    wx.showToast({
      title: '结算成功',
      icon: 'success',
      duration: 2000
    });
    console.log('订单数据写入成功：', res);
    // 跳转到订单详情页
    wx.navigateTo({
      url: '/pages/xiangqing/xiangqing'
    });
    // 订单提交成功后清空购物车
    this.clearCart();
  }).catch(err => {
    wx.showToast({
      title: '结算失败',
      icon: 'none',
      duration: 2000
    });
    console.error('订单数据写入失败：', err);
  });
},

  // 立即购买：存入新的 purchaseOrders 集合
// 立即购买方法（逻辑同 onCheckout，可类似修改）
buyNow() {
  const app = getApp();
  const { selectedItem, cupType, sweetness, temperature, toppings, quantity } = this.data;

  // 检查是否登录（openidRandom 是否存在）
  const openidRandom = wx.getStorageSync('openidRandom');
  if (!openidRandom) {
    // 自动调用登录流程，登录完成后再重新执行 onCheckout
      // 气泡提示“请先登录”
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
    this.getUserProfile(() => {
      this.onCheckout(); // 登录成功后再次执行结算逻辑
    });
    return;
  }

  // 检查是否选择了规格
  if (!cupType || !sweetness || !temperature) {
    wx.showToast({
      title: '请先选择规格',
      icon: 'none',
      duration: 2000
    });
    return;
  }

  // 收起弹出层（关闭商品详情弹窗）
  this.onClose(); // 或者直接使用： this.setData({ show: false });

  // 计算单件商品选中小料的总价
  let unitToppingsPrice = 0;
  const updatedToppings = toppings.filter(t => t.quantity > 0).map(t => {
    unitToppingsPrice += t.quantity * t.price;
    return {
      ...t,
      quantity: t.quantity * quantity
    };
  });
  const itemTotalPrice = (selectedItem.showPriceLow + unitToppingsPrice) * quantity;
  
  // 构造订单数据对象
  const orderData = {
    userId: wx.getStorageSync('userId') || 'unknown',
    orderId: new Date().getTime(),
    items: [{
      id: selectedItem.id || new Date().getTime(),
      item: selectedItem,
      options: {
        cupType,
        sweetness,
        temperature,
        toppings: updatedToppings
      },
      quantity,
      totalPrice: itemTotalPrice,
    }],
    totalPrice: itemTotalPrice,
    createdAt: new Date(),
    openidRandom: openidRandom,
    orderStatus: '未付款'
  };

  app.globalData.orderData = orderData;
  console.log("订单数据已存入 globalData:", app.globalData.orderData);

  const db = wx.cloud.database();
  db.collection('orders').add({
    data: orderData
  }).then(res => {
    wx.showToast({
      title: '订单已创建',
      icon: 'success',
      duration: 2000
    });
    console.log('订单数据写入成功：', res);
    wx.navigateTo({
      url: '/pages/xiangqing/xiangqing'
    });
  }).catch(err => {
    wx.showToast({
      title: '创建订单失败',
      icon: 'none',
      duration: 2000
    });
    console.error('订单写入失败：', err);
  });
},




  removeCartItem(event) {
    const index = event.currentTarget.dataset.index;
    let cartItems = this.data.cartItems;

    wx.showModal({
      title: '确认删除',
      content: '确定要删除该商品吗？',
      success: (res) => {
        if (res.confirm) {
          cartItems.splice(index, 1); // 删除商品

          // 计算新购物车数量
          const newCartItemCount = cartItems.reduce((sum, item) => sum + item.quantity, 0);

          // 更新数据
          this.setData({
            cartItems,
            cartItemCount: newCartItemCount,
            cartTotalPrice: this.calculateTotal(cartItems),
            cartVisible: newCartItemCount > 0 // 购物车为空时隐藏
          });

          wx.showToast({
            title: '已删除',
            icon: 'success'
          });
        }
      }
    });
  },


  // 计算购物车总价
  calculateTotal(cartItems) {
    return cartItems.reduce((sum, item) => sum + item.totalPrice, 0);
  },

  // 其他已有的代码（如页面加载、滚动监听、侧边栏点击等）……
  onLoad() {
    // 模拟请求数据
    const pastData = require('../../assets/diandan1');
    const categoryItems = pastData.postData.list[0].data.categoryItems.slice(1);
    this.setData({
      categoryItems
    }, () => {
      this.calculateSectionHeights();
    });
  },

  calculateSectionHeights() {
    const query = this.createSelectorQuery();
    const sectionHeights = [];
    let cumulativeHeight = 0;

    query.selectAll(".category-section").boundingClientRect((res) => {
      res.forEach(item => {
        cumulativeHeight += item.height;
        sectionHeights.push(cumulativeHeight);
      });
      this.setData({
        sectionHeights
      });
    }).exec();
  },

  onScroll(event) {
    const scrollTop = event.detail.scrollTop;
    const sectionHeights = this.data.sectionHeights;
    let activeKey = 0;
    for (let i = 0; i < sectionHeights.length; i++) {
      if (scrollTop < sectionHeights[i]) {
        activeKey = i;
        break;
      }
    }
    if (activeKey !== this.data.activeKey) {
      this.setData({
        activeKey
      });
    }
  },

  onSidebarItemClick(event) {
    const index = event.currentTarget.dataset.index;
    this.setData({
      activeKey: index,
      scrollToId: `category-${index}`
    });
  },
});